home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / deskbar-applet / handlers / programs.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-04-29  |  14.4 KB  |  359 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import os
  5. import ConfigParser
  6. import cgi
  7. import re
  8. import glob
  9. from os.path import join, isfile, abspath, splitext, expanduser, exists, isdir
  10. from gettext import gettext as _
  11. from deskbar.defs import VERSION
  12. import gobject
  13. import gtk
  14. import deskbar
  15. import deskbar.Indexer as deskbar
  16. import deskbar.Utils as deskbar
  17. import deskbar.Handler as deskbar
  18. import deskbar.Match as deskbar
  19. import deskbar.gnomedesktop as deskbar
  20. from deskbar.Utils import get_xdg_data_dirs, is_program_in_path, spawn_async
  21. HANDLERS = {
  22.     'ProgramsHandler': {
  23.         'name': _('Programs'),
  24.         'description': _('Launch a program by its name and/or description'),
  25.         'version': VERSION },
  26.     'GnomeDictHandler': {
  27.         'name': _('Dictionary'),
  28.         'description': _('Look up word definitions in the dictionary'),
  29.         'version': VERSION },
  30.     'GnomeSearchHandler': {
  31.         'name': _('Files and Folders Search'),
  32.         'description': _('Find files and folders by searching for a name pattern'),
  33.         'version': VERSION },
  34.     'DevhelpHandler': {
  35.         'name': _('Developer Documentation'),
  36.         'description': _('Search Devhelp for a function name'),
  37.         'version': VERSION } }
  38. EXACT_MATCH_PRIO = 100
  39. EXACT_WORD_PRIO = 50
  40.  
  41. class GenericProgramMatch(deskbar.Match.Match):
  42.     
  43.     def __init__(self, backend, use_arg = False, desktop = None, desktop_file = None, **args):
  44.         deskbar.Match.Match.__init__(self, backend, **args)
  45.         self.desktop_file = desktop_file
  46.         self.use_arg = use_arg
  47.         self._priority = EXACT_WORD_PRIO
  48.         self._icon = deskbar.Utils.load_icon_for_desktop_icon(self.icon)
  49.         self._desktop = desktop
  50.         if desktop == None:
  51.             self._desktop = parse_desktop_filename(desktop_file)
  52.             if self._desktop == None:
  53.                 raise Exception('Desktop file not found, ignoring')
  54.             
  55.         
  56.         exe = re.sub('%\\w+', '', self._desktop.get_string('Exec'))
  57.         i = exe.split(' ')[0].rfind('/')
  58.         if i != -1:
  59.             exe = exe[i + 1:]
  60.         
  61.         self._display_prog = cgi.escape(exe).strip()
  62.  
  63.     
  64.     def get_hash(self, text = None):
  65.         return 'generic_' + self._display_prog
  66.  
  67.     
  68.     def action(self, text = None):
  69.         if self.use_arg and text != None:
  70.             args = [
  71.                 self._desktop.get_string('Exec')]
  72.             if hasattr(self, '_args'):
  73.                 args = args + self._args
  74.             
  75.             args = args + [
  76.                 text]
  77.             spawn_async(args)
  78.         else:
  79.             
  80.             try:
  81.                 self._desktop.launch([])
  82.             except Exception:
  83.                 e = None
  84.                 print 'Warning:Could not launch .desktop file:', e
  85.  
  86.  
  87.     
  88.     def get_category(self):
  89.         return 'actions'
  90.  
  91.     
  92.     def get_verb(self):
  93.         return _('Launch <b>%(name)s</b> (%(prog)s)')
  94.  
  95.     
  96.     def get_name(self, text = None):
  97.         return {
  98.             'name': self.name,
  99.             'prog': self._display_prog }
  100.  
  101.  
  102.  
  103. class GnomeDictMatch(GenericProgramMatch):
  104.     
  105.     def __init__(self, backend, use_arg = True, **args):
  106.         GenericProgramMatch.__init__(self, backend, use_arg = use_arg, **args)
  107.         self._args = [
  108.             '--look-up']
  109.  
  110.     
  111.     def get_verb(self):
  112.         return _('Lookup %s in dictionary') % '<b>%(text)s</b>'
  113.  
  114.  
  115.  
  116. class GnomeSearchMatch(GenericProgramMatch):
  117.     
  118.     def __init__(self, backend, use_arg = True, **args):
  119.         GenericProgramMatch.__init__(self, backend, use_arg = use_arg, **args)
  120.         self._args = [
  121.             '--start',
  122.             '--path',
  123.             expanduser('~'),
  124.             '--named']
  125.  
  126.     
  127.     def get_verb(self):
  128.         return _('Search for file names like %s') % '<b>%(text)s</b>'
  129.  
  130.  
  131.  
  132. class DevhelpMatch(GenericProgramMatch):
  133.     
  134.     def __init__(self, backend, use_arg = True, **args):
  135.         GenericProgramMatch.__init__(self, backend, use_arg = use_arg, **args)
  136.         self._args = [
  137.             '-s']
  138.  
  139.     
  140.     def get_verb(self):
  141.         return _('Search in Devhelp for %s') % '<b>%(text)s</b>'
  142.  
  143.  
  144.  
  145. class SpecialProgramHandler(deskbar.Handler.Handler):
  146.     
  147.     def __init__(self, desktop, icon = gtk.STOCK_EXECUTE):
  148.         deskbar.Handler.Handler.__init__(self, icon)
  149.         self._desktop = desktop
  150.         self._match = None
  151.  
  152.     
  153.     def initialize(self):
  154.         result = parse_desktop_filename(self._desktop, False)
  155.         if result != None:
  156.             self._match = self.create_match(result, self._desktop)
  157.         
  158.  
  159.     
  160.     def create_match(self, desktop, f):
  161.         raise NotImplementedError
  162.  
  163.     
  164.     def query(self, qstring):
  165.         if self._match != None:
  166.             self._match._priority = get_priority_for_name(qstring, self._match._desktop.get_string('Exec'))
  167.             return [
  168.                 self._match]
  169.         else:
  170.             return []
  171.  
  172.  
  173.  
  174. class GnomeDictHandler(SpecialProgramHandler):
  175.     
  176.     def __init__(self):
  177.         SpecialProgramHandler.__init__(self, 'gnome-dictionary.desktop', 'gdict')
  178.  
  179.     
  180.     def create_match(self, desktop, f):
  181.         return GnomeDictMatch(self, name = cgi.escape(desktop.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = desktop.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = desktop, desktop_file = f)
  182.  
  183.  
  184.  
  185. class GnomeSearchHandler(SpecialProgramHandler):
  186.     
  187.     def __init__(self):
  188.         SpecialProgramHandler.__init__(self, 'gnome-search-tool.desktop', 'gnome-searchtool')
  189.  
  190.     
  191.     def create_match(self, desktop, f):
  192.         return GnomeSearchMatch(self, name = cgi.escape(desktop.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = desktop.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = desktop, desktop_file = f)
  193.  
  194.  
  195.  
  196. class DevhelpHandler(SpecialProgramHandler):
  197.     
  198.     def __init__(self):
  199.         SpecialProgramHandler.__init__(self, 'devhelp.desktop', 'devhelp')
  200.  
  201.     
  202.     def create_match(self, desktop, f):
  203.         return DevhelpMatch(self, name = cgi.escape(desktop.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = desktop.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = desktop, desktop_file = f)
  204.  
  205.  
  206.  
  207. class PathProgramMatch(deskbar.Match.Match):
  208.     
  209.     def __init__(self, backend, name = None, use_terminal = False, priority = 0, **args):
  210.         deskbar.Match.Match.__init__(self, backend, name = name, **args)
  211.         self.use_terminal = use_terminal
  212.         self._priority = EXACT_MATCH_PRIO
  213.  
  214.     
  215.     def set_with_terminal(self, terminal):
  216.         self.use_terminal = terminal
  217.  
  218.     
  219.     def get_hash(self, text = None):
  220.         if not self.use_terminal:
  221.             return text
  222.         else:
  223.             return (text, True)
  224.  
  225.     
  226.     def action(self, text = None):
  227.         if self.use_terminal:
  228.             
  229.             try:
  230.                 prog = subprocess.Popen(text.split(' '), stdout = subprocess.PIPE, stderr = subprocess.STDOUT)
  231.                 zenity = subprocess.Popen([
  232.                     'zenity',
  233.                     '--title=' + text,
  234.                     '--window-icon=' + join(deskbar.ART_DATA_DIR, 'generic.png'),
  235.                     '--width=700',
  236.                     '--height=500',
  237.                     '--text-info'], stdin = prog.stdout)
  238.                 gobject.child_watch_add(zenity.pid, (lambda pid, code: pass))
  239.                 gobject.child_watch_add(prog.pid, (lambda pid, code: pass))
  240.                 return None
  241.  
  242.         
  243.         spawn_async(text.split(' '))
  244.  
  245.     
  246.     def get_category(self):
  247.         return 'actions'
  248.  
  249.     
  250.     def get_verb(self):
  251.         return _('Execute %s') % '<b>%(text)s</b>'
  252.  
  253.  
  254.  
  255. class ProgramsHandler(deskbar.Handler.Handler):
  256.     
  257.     def __init__(self):
  258.         deskbar.Handler.Handler.__init__(self, gtk.STOCK_EXECUTE)
  259.         self._indexer = deskbar.Indexer.Indexer()
  260.  
  261.     
  262.     def initialize(self):
  263.         self._scan_desktop_files()
  264.  
  265.     
  266.     def query(self, query):
  267.         result = self.query_path_programs(query)
  268.         result += self.query_desktop_programs(query)
  269.         return result
  270.  
  271.     
  272.     def query_path_programs(self, query):
  273.         args = query.split(' ')
  274.         match = self._check_program(args[0])
  275.         if match != None:
  276.             return [
  277.                 match]
  278.         else:
  279.             return []
  280.  
  281.     
  282.     def query_desktop_programs(self, query):
  283.         result = []
  284.         for match in self._indexer.look_up(query):
  285.             match._priority = get_priority_for_name(query, match._desktop.get_string('Exec'))
  286.             result.append(match)
  287.         
  288.         return result
  289.  
  290.     
  291.     def on_key_press(self, query, shortcut):
  292.         if shortcut == gtk.keysyms.t:
  293.             match = self._check_program(query.split(' ')[0])
  294.             if match != None:
  295.                 match.set_with_terminal(True)
  296.                 return match
  297.             
  298.         
  299.  
  300.     
  301.     def _check_program(self, program):
  302.         if is_program_in_path(program):
  303.             return PathProgramMatch(self, program)
  304.         
  305.  
  306.     
  307.     def _scan_desktop_files(self):
  308.         for dir in get_xdg_data_dirs():
  309.             for f in glob.glob(join(dir, 'applications', '*.desktop')):
  310.                 result = parse_desktop_file(f)
  311.                 if result != None:
  312.                     match = GenericProgramMatch(self, name = cgi.escape(result.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = result.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = result, desktop_file = f)
  313.                     self._indexer.add('%s %s %s %s %s' % (result.get_string('Exec'), result.get_localestring(deskbar.gnomedesktop.KEY_NAME), result.get_localestring(deskbar.gnomedesktop.KEY_COMMENT), result.get_string(deskbar.gnomedesktop.KEY_NAME), result.get_string(deskbar.gnomedesktop.KEY_COMMENT)), match)
  314.                     continue
  315.             
  316.         
  317.  
  318.  
  319.  
  320. def get_priority_for_name(query, name):
  321.     if name.split(' ')[0].endswith(query):
  322.         return EXACT_MATCH_PRIO
  323.     else:
  324.         return EXACT_WORD_PRIO
  325.  
  326.  
  327. def parse_desktop_filename(desktop, only_if_visible = True):
  328.     if desktop[0] == '/' and exists(desktop):
  329.         return parse_desktop_file(desktop, only_if_visible)
  330.     
  331.     for dir in get_xdg_data_dirs():
  332.         f = join(dir, 'applications', desktop)
  333.         if exists(f):
  334.             return parse_desktop_file(f, only_if_visible)
  335.             continue
  336.     
  337.  
  338.  
  339. def parse_desktop_file(desktop, only_if_visible = True):
  340.     
  341.     try:
  342.         desktop = deskbar.gnomedesktop.item_new_from_file(desktop, deskbar.gnomedesktop.LOAD_ONLY_IF_EXISTS)
  343.     except Exception:
  344.         e = None
  345.         print "Couldn't read desktop file:%s:%s" % (desktop, e)
  346.         return None
  347.  
  348.     if desktop == None or desktop.get_entry_type() != deskbar.gnomedesktop.TYPE_APPLICATION:
  349.         return None
  350.     
  351.     if desktop.get_boolean(deskbar.gnomedesktop.KEY_TERMINAL):
  352.         return None
  353.     
  354.     if only_if_visible and desktop.get_boolean(deskbar.gnomedesktop.KEY_NO_DISPLAY):
  355.         return None
  356.     
  357.     return desktop
  358.  
  359.